/*
 * 原版接口
 */
import * as server_ui from "@minecraft/server-ui";
import * as server from "@minecraft/server";
/*
 * 蛋白石数据
 */
import * as data_prompt from "../data/prompt";
import * as data_format from "../data/format";
import * as data_block from "../data/block";
import * as data_story from "../data/story";
/*
 * 蛋白石组件
 */
import * as derived_tools from "../system/derived_tools";
import * as native_tools from "../system/native_tools";
import * as achieve_plan from "../system/achieve_plan";
import * as query_intel from "../system/query_intel";
import * as math_tools from "../system/math_tools";
/**
 * * 精灵治愈
 */
export function FaerieHealingTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 100)) return;
            /** 
             * * 定义 查询实体 的 参数
             */
            const options: server.EntityQueryOptions = {
                excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
                excludeFamilies: ["monster"],
                location: player.location,
                maxDistance: 8
            };
            // 获取 附近的实体 并 赋予 生命恢复效果
            player.dimension.getEntities(options).forEach(entity => entity.addEffect("regeneration", 300, { amplifier: 4, showParticles: false }));
            /**
             * * 定义 粒子参数
             */
            const molang = new server.MolangVariableMap(); molang.setFloat('variable.size', 8); molang.setFloat('variable.direction', 3);
            // 播放 音效
            player.playSound('item.book.page_turn');
            // 播放 粒子效果
            native_tools.TrySpawnParticle(player.dimension, 'scripts:path_spiral', player.location, molang);
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 林业指南
 */
export function ForestryGuidelinesTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 100)) return;
            /**
             * * 定义 起始点
             */
            const start = math_tools.Vector.add(player.location, { x: -5, y: -1, z: -5 });
            /**
             * * 定义 结束点
             */
            const done = math_tools.Vector.add(player.location, { x: 5, y: 15, z: 5 });
            /** 
             * * 在 绘制路径 时 执行 的 程序
             */
            const moveEvent = (args: data_format.ROUTE_ANNEX_ARGS) => {
                /** 
                 * * 检测方块是否需要被挖掘
                 */
                const TestSort = () => {
                    /** 
                     * * 获取 方块对象
                     */
                    const getBlock = args.dimension.getBlock(args.location);
                    // 检测 方块类型
                    if (getBlock) return data_block.is_trees.has(getBlock.typeId);
                    else return false
                }
                //执行路径事件的功能
                if (TestSort()) args.dimension.runCommand(`fill ${args.location.x} ${args.location.y} ${args.location.z} ${args.location.x} ${args.location.y} ${args.location.z} air [] destroy`)
                // 继续循环
                return true
            };
            // 播放 音效
            player.playSound('item.book.page_turn');
            // 创建 路径执行计划
            achieve_plan.PathExecute.CreateForCube(
                '林业指南-范围扫描',
                {
                    particles: ['constant:track_rune_green'],
                    location_group: [],
                    dimension: player.dimension,
                    cooldown: 1,
                    speed: 1,
                    on_move: moveEvent
                },
                start, done, 0.25
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 矿物辞典
 */
export function MineralDictionaryTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 100)) return;
            /**
             * * 定义 起始点
             */
            const start = math_tools.Vector.add(player.location, { x: -5, y: -9, z: -5 });
            /**
             * * 定义 结束点
             */
            const done = math_tools.Vector.add(player.location, { x: 5, y: 9, z: 5 });
            /** 
             * * 在 绘制路径 时 执行 的 程序
             */
            const moveEvent = (args: data_format.ROUTE_ANNEX_ARGS) => {
                /** 
                 * * 检测方块是否需要被挖掘
                 */
                const TestSort = () => {
                    /** 
                     * * 获取 方块对象
                     */
                    const getBlock = args.dimension.getBlock(args.location);
                    // 检测 方块类型
                    if (getBlock) return data_block.is_mineral.has(getBlock.typeId);
                    else return false
                }
                //执行路径事件的功能
                if (TestSort()) {
                    // 执行填充方块命令
                    args.dimension.runCommand(`fill ${args.location.x} ${args.location.y} ${args.location.z} ${args.location.x} ${args.location.y} ${args.location.z} air [] destroy`)
                    /**
                     * * 定义 掉落物 的 参数
                     */
                    const options: server.EntityQueryOptions = {
                        location: args.location,
                        type: "minecraft:item",
                        maxDistance: 4
                    };
                    // 获取附近的掉落物
                    args.dimension.getEntities(options).forEach(entity => entity.teleport(player.getHeadLocation(), { dimension: player.dimension }));
                }
                // 继续循环
                return true
            };
            // 播放 音效
            player.playSound('item.book.page_turn');
            // 创建 路径执行计划
            achieve_plan.PathExecute.CreateForCube(
                '矿物辞典-范围扫描',
                {
                    particles: ['constant:track_color_indigo'],
                    location_group: [],
                    dimension: player.dimension,
                    cooldown: 1,
                    speed: 1,
                    on_move: moveEvent
                },
                start, done, 0.25
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 空间宝典
 */
export function SpaceTransitionTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 100)) return;
            /**
             * * 诸界道标 数据信息
             */
            const RoadSign = new Map<string, data_format.LOCATION_AND_DIMENSION>()
            // 获取 所有 道标
            player.getDynamicPropertyIds().filter(id => id.startsWith('road_sign:')).forEach(id => native_tools.CompileSign(player, id, RoadSign));
            // 播放 音效
            player.playSound('item.book.page_turn');
            //当玩家处于潜行时 触发的随机传送机制
            if (player.isSneaking) {
                /** 
                 * * 获取 可用 的 着陆点
                 */
                const anchor = math_tools.QueryEntityFoothold(player, 10, 512);
                //执行传送流程 并 播放音效
                if (math_tools.Vector.distance(anchor, player.location) > 3) player.teleport(anchor);
                // 播放音效
                server.system.runTimeout(() => player.playSound("conduit.attack"), 5);
            }
            else BasePresets().show(player).then(
                option => {
                    if (option.canceled) return;
                    switch (option.selection) {
                        //相对传送
                        case 0: RelativePresets().show(player).then(option => RenRelative(player, option)); break;

                        //随机传送
                        case 1: RandomPresets().show(player).then(option => RenRandom(player, option)); break;

                        //诸界道标
                        case 2: SignPresets(RoadSign).show(player).then(option => RenRoadSign(player, option, RoadSign)); break;
                    }
                }
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 用于显示各种传送模式的基础窗口
 */
function BasePresets() {
    /** 
     * * 定义了 窗口界面 的 标题 
     */
    const title: server.RawMessage = {
        text: "§9《§5 空间宝典 §9》§r"
    };
    /** 
     * * 定义了 窗口界面 的 选项
     */
    const option: server.RawMessage[] = [
        { text: '<§4§o§l 相对传送 §r>' },
        { text: '<§5§o§l 随机传送 §r>' },
        { text: '<§9§o§l 诸界道标 §r>' }
    ];
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData()
        .title(title)
        .button(option[0], "textures/物品贴图/魔法书籍/空间宝典")
        .button(option[1], "textures/物品贴图/魔法书籍/魔导手册")
        .button(option[2], "textures/物品贴图/魔法书籍/空间宝典")
    //输出 表单对象
    return display
};
/**
 * * 用于显示[ 相对坐标 ]< 传送机制 >的设置窗口
 */
function RelativePresets() {
    /** 
     * * 定义了 窗口界面 的 标题
     */
    const title: server.RawMessage = {
        text: "§9《§5 空间宝典 §9》§r"
    };
    /** 
     * * 定义了 窗口界面 的 滑动条标题
     */
    const option: server.RawMessage[] = [
        { text: '§3相对§a X轴坐标§r' },
        { text: '§3相对§a Y轴坐标§r' },
        { text: '§3相对§a Z轴坐标§r' }
    ];
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ModalFormData()
        .title(title)
        .slider(option[0], -64, 64, 1, 0)
        .slider(option[1], -64, 64, 1, 0)
        .slider(option[2], -64, 64, 1, 0)
    //输出 表单对象
    return display
};
/**
 * * 用于显示[ 随机坐标 ]< 传送机制 >的设置窗口
 */
function RandomPresets() {
    /** 定义了 窗口界面 的 标题 */
    const title: server.RawMessage = {
        text: "§9《§5 空间宝典 §9》§r"
    };
    /** 定义了 窗口界面 的 滑动条标题 */
    const option: server.RawMessage[] = [
        { text: '§3偏移§a X轴基准§r' },
        { text: '§3偏移§a Y轴基准§r' },
        { text: '§3偏移§a Z轴基准§r' },
        { text: '§3设置§a 极限范围§r' }
    ];
    /** 定义了 窗口界面 的 表单对象 */
    const display = new server_ui.ModalFormData()
        .title(title)
        .slider(option[0], -16, 16, 1, 0)
        .slider(option[1], -16, 16, 1, 0)
        .slider(option[2], -16, 16, 1, 0)
        .slider(option[3], 16, 255, 1, 16)
    //输出 表单对象
    return display
};
/**
 * * 用于显示[ 诸界道标 ]< 传送机制 >的设置窗口
 */
function SignPresets(input: Map<string, data_format.LOCATION_AND_DIMENSION>) {
    /**
     * * 获取 道标名称
     */
    const name = Array.from(input.keys()).map(id => `§n§o§l§${Math.floor(Math.random() * 6)}` + id.split(':')[1]);
    /** 定义了 窗口界面 的 标题 */
    const title: server.RawMessage = {
        text: "§9《§5 空间宝典 §9》§r"
    };
    /** 定义了 窗口界面 的 选项 */
    const option: server.RawMessage[] = [
        { text: '<§2§o§l 创建道标 §r>' },
        { text: '<§5§o§l 道标传送 §r>' },
        { text: '<§4§o§l 移除道标 §r>' }
    ];
    /** 定义了 窗口界面 的 输入栏提示 */
    const text: server.RawMessage[] = [
        { text: '<§2§o§l 识别标签 §r> -> §9重命名' },
        { text: '§c请输入 诸界道标 识别标签§r' },
        { text: '§c是否启用<§2§o§l 雾海裂隙 §r>§r' }
    ];
    /** 定义了 窗口界面 的 表单对象 */
    const display = new server_ui.ModalFormData()
        .title(title)
        .dropdown('', name.length !== 0 ? name : ["§4暂无 §9道标信息§r"], name.length > 1 ? name.length - 1 : 0)
        .dropdown('', option, name.length !== 0 ? 1 : 0)
        .textField(text[0], text[1], math_tools.NumberID().toString())
        .toggle(text[2], false)
    //输出 表单对象
    return display
};
/**
 * * 执行 相对传送
 */
function RenRelative(player: server.Player, option: server_ui.ModalFormResponse) {
    //检测玩家是否退出窗口
    if (option.canceled) return;
    /** 
     * * 获取 目标位置
     */
    const location = math_tools.Vector.add(player.location,
        {
            x: parseInt((option.formValues as any[])[0]),
            y: parseInt((option.formValues as any[])[1]),
            z: parseInt((option.formValues as any[])[2]),
        }
    );
    // 传送玩家
    player.teleport(location);
    // 播放音效
    server.system.runTimeout(() => player.playSound("mob.endermen.portal"), 2);
};
/**
 * * 执行 随机传送
 */
function RenRandom(player: server.Player, option: server_ui.ModalFormResponse) {
    //检测玩家是否退出窗口
    if (option.canceled) return
    /** 
     * * 获取 目标位置
     */
    const location = math_tools.Vector.add(player.location,
        {
            x: parseInt((option.formValues as any[])[0]),
            y: parseInt((option.formValues as any[])[1]),
            z: parseInt((option.formValues as any[])[2]),
        }
    );
    /**
     * * 获取锚点位置
     */
    const anchor = math_tools.QueryFoothold({ location: location, dimension: player.dimension }, parseInt((option.formValues as any[])[3]), -60, 300);
    // 传送玩家
    player.teleport(anchor);
    // 播放音效
    server.system.runTimeout(() => player.playSound("mob.endermen.portal"), 5);
};
/**
 * * 执行 道标传送
 */
function RenRoadSign(player: server.Player, option: server_ui.ModalFormResponse, input: Map<string, data_format.LOCATION_AND_DIMENSION>) {
    //检测玩家是否退出窗口
    if (!option.formValues) return
    /**
     * * 获取 道标参数
     */
    const value = Array.from(input.values());
    /**
     * * 获取 道标名称
     */
    const name = Array.from(input.keys());
    /**
     * * 指向 玩家 开始传送的 位置
     */
    const pointLocation = player.location;
    /**
     * * 指向 玩家 开始传送的 维度
     */
    const pointDimension = player.dimension;
    /**
     * * 获取 玩家的 输入信息
     */
    const forms: any[] = option.formValues;
    /**
     * * 获取 玩家自身 的 锚点信息
     */
    const selfAnchor = JSON.stringify({ location: player.location, dimension: player.dimension.id });
    // 根据 选项 进行 不同 处理
    switch (forms[1]) {
        //新增 道标信息
        case 0: player.setDynamicProperty('road_sign:' + forms[2], selfAnchor); break;

        //使用 道标信息
        case 1:
            // 判断是否开启 雾海裂隙
            if (forms[3]) server.system.runTimeout(() => MistySeaFissure(player, pointLocation, pointDimension), 5)
            // 传送玩家
            player.teleport(value[forms[0]].location, { dimension: value[forms[0]].dimension });
            // 播放音效
            server.system.runTimeout(() => player.playSound("mob.endermen.portal"), 5);
            break;

        //移除 道标信息
        case 2: player.setDynamicProperty(name[forms[0]]); break;
    };
};
/**
 * * 执行 雾海裂隙
 */
function MistySeaFissure(player: server.Player, location: server.Vector3, dimension: server.Dimension) {
    /**
     * * 获取 玩家自身 的 锚点信息
     */
    const origin = math_tools.Vector.add(player.location, math_tools.Vector.CONSTANT_UP);
    // 创建 雾海裂隙
    server.system.runTimeout(
        () => {
            achieve_plan.MistySeaFissure.Create('', 30,
                {
                    location_group: [
                        origin,
                        location
                    ],
                    dimension_group: [
                        player.dimension,
                        dimension
                    ]
                }
            );
            player.playSound("ambient.weather.thunder", { location: player.location, volume: 10 });
            native_tools.TrySpawnParticle(player.dimension, 'constant:fireworks_fireball_amber_color', origin);
            native_tools.TrySpawnParticle(player.dimension, 'constant:smoke_rune_white', origin);
        },
        100
    )
};
/**
 * * 精灵结契
 */
export function FaerieContractTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 100)) return;
            /** 
             * * 设定查询参数
             */
            const options: server.EntityQueryOptions = {
                excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
                excludeFamilies: ["monster"]
            };
            /**
             * * 获取 实体 的 距离信息
             */
            const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
            /**
             * * 获取 实体组 并 过滤掉 无法驯服的实体
             */
            const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), entity => entity.getComponent('minecraft:tameable'));
            /** 
             * * 定义了 窗口界面 的 标题 
             */
            const title: server.RawMessage = {
                text: "§9《§5 精灵结契 §9》§r"
            };
            /** 
             * * 定义了 窗口界面 的 表单对象
             */
            const display = new server_ui.ActionFormData().title(title);
            /** 
             * * 获取 实体 的 名称信息
             */
            const Intel = (entity: server.Entity): server.RawMessage => {
                return {
                    rawtext: [
                        { text: '§l' },
                        native_tools.EntityTranslate(entity),
                        { text: `\n§9距离: §5${Distance(entity)}` }
                    ]
                }
            };
            // 遍历 实体数组 并 加入 按钮
            if (queue.length >= 1) queue.forEach(entity => display.button(Intel(entity), "textures/物品贴图/魔法书籍/精灵结契"));
            else display.button('§4§l周围不存在 §c<§9 可以§6<§u 契约 §6>§9的实体 §c>§r', "textures/物品贴图/魔法书籍/战术规划");
            // 播放 音效
            player.playSound('item.book.page_turn');
            // 显示 窗口界面
            display.show(player).then(
                option => {
                    if (option.selection == undefined || queue.length == 0) return;
                    // 契约 实体
                    queue[option.selection].getComponent('minecraft:tameable')?.tame(player);
                    // 移除 物品
                    server.system.runTimeout(() => container?.setItem(player.selectedSlotIndex), 5);
                    // 播放 音效
                    server.system.runTimeout(() => player.playSound('conduit.deactivate'), 1);
                }
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
        }
    }
};
/**
 * * 魔法绪论
 */
export function IntroductionMagicTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            // 判断条件是否满足
            if (!player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            // 显示 区块边界
            derived_tools.DisplayChunkBoundary(player);
            /**
             * * 获得 区块坐标
             */
            const chunk = math_tools.Vector.chunkLocation(player.location);
            /**
             * * 获取 当前区块的消息通知
             */
            const notify = data_story.message_notify.get(math_tools.Vector.toString(chunk));
            // 判断当前区块是否具有消息通知
            if (!notify || notify.size < 1) return player.playSound('respawn_anchor.deplete');
            /**
             * * 消息通知 的 类型
             */
            const keys = Array.from(notify.keys());
            /**
             * * 获取 消息通知 的 内容信息
             */
            const value = Array.from(notify.values());
            /** 
             * * 定义了 窗口界面 的 标题 
             */
            const title: server.RawMessage = { text: "§9《§5 魔导绪论 §9》§r" };
            /**
             * * 当前区块内 消息通知 的 全部内容
             */
            const rawMessage: server.RawMessage = { rawtext: [] };
            /** 
             * * 定义了 窗口界面 的 表单对象
             */
            const display = new server_ui.ActionFormData().title(title).button('§u§l关闭§r').button('§4§l清除§r');
            // 编写 消息通知 的 内容信息
            keys.forEach(
                (key, index) => {
                    rawMessage.rawtext?.push({ text: `『 ${key} 』\n` }, value[index], { text: '\n\n=====================\n' });
                }
            );
            // 将 消息通知 的 内容信息 写入 窗口界面
            display.body(rawMessage);
            // 显示 窗口界面
            display.show(player).then(
                option => {
                    if (option.canceled || option.selection == undefined) return;
                    if (option.selection == 1) notify.clear();
                }
            );
            // 播放 使用音效
            player.playSound('beacon.activate');
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
        }
    }
};
/**
 * * 源能秘典 
 */
export function SourceEnergyTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            // 判断条件是否满足
            if (!player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            /**
             * * 引导文本 的 标题
             */
            const keys = Array.from(data_prompt.entry.keys());
            /**
             * * 引导文本 的 内容
             */
            const value = Array.from(data_prompt.entry.values()).map(item => item.map(info => info.refer));
            /** 
             * * 定义了 窗口界面 的 标题 
             */
            const title: server.RawMessage = {
                text: "§9《§5 源能秘典 §9》§r"
            };
            /** 
             * * 定义了 窗口界面 的 表单对象
             */
            const display = new server_ui.ActionFormData().title(title);
            // 遍历 引导文本 并 加入 按钮
            keys.forEach(key => display.button('§l§u' + key, "textures/物品贴图/魔法书籍/源能秘典"));
            // 显示 窗口界面
            display.show(player).then(
                option => {
                    if (option.canceled || option.selection == undefined) return;
                    // 显示 窗口界面
                    new server_ui.ActionFormData()
                        .title('§l§u§o' + keys[option.selection])
                        .body({ rawtext: value[option.selection] })
                        .button('§4§l关闭§r')
                        .show(player)
                }
            );
            // 播放 使用音效
            player.playSound('item.book.page_turn');
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
        }
    }
};
/**
 * * 定义 魔导手册 功能
 */
export function MagicHandbook(player: server.Player, item: server.ItemStack, block?: server.Block) {
    // 播放 音效
    player.playSound('item.book.page_turn');
    // 显示 窗口界面
    if (block) query_intel.GameHelp(player, block);
    // 更新 物品冷却
    item.getComponent('minecraft:cooldown')?.startCooldown(player);
};